package br.edu.ufcg.dsc.psoo.mymoney.controller.test.acceptance;

import java.io.FileNotFoundException;
import java.util.List;

import org.hibernate.SessionFactory;

import br.edu.ufcg.dsc.psoo.mymoney.controller.AccountController;
import br.edu.ufcg.dsc.psoo.mymoney.controller.GroupController;
import br.edu.ufcg.dsc.psoo.mymoney.controller.MovementController;
import br.edu.ufcg.dsc.psoo.mymoney.controller.TypeController;
import br.edu.ufcg.dsc.psoo.mymoney.controller.UserController;
import br.edu.ufcg.dsc.psoo.mymoney.controller.exceptions.AccountNotFoundException;
import br.edu.ufcg.dsc.psoo.mymoney.controller.exceptions.GroupNotFoundException;
import br.edu.ufcg.dsc.psoo.mymoney.controller.exceptions.InvalidAccountException;
import br.edu.ufcg.dsc.psoo.mymoney.controller.exceptions.InvalidFileException;
import br.edu.ufcg.dsc.psoo.mymoney.controller.exceptions.InvalidGroupException;
import br.edu.ufcg.dsc.psoo.mymoney.controller.exceptions.InvalidMovementException;
import br.edu.ufcg.dsc.psoo.mymoney.controller.exceptions.InvalidTypeException;
import br.edu.ufcg.dsc.psoo.mymoney.controller.exceptions.InvalidUserException;
import br.edu.ufcg.dsc.psoo.mymoney.controller.exceptions.TypeNotFoundException;
import br.edu.ufcg.dsc.psoo.mymoney.controller.exceptions.UserNotFoundException;
import br.edu.ufcg.dsc.psoo.mymoney.controller.implementation.AccountControllerImpl;
import br.edu.ufcg.dsc.psoo.mymoney.controller.implementation.GroupControllerImpl;
import br.edu.ufcg.dsc.psoo.mymoney.controller.implementation.MovementControllerImpl;
import br.edu.ufcg.dsc.psoo.mymoney.controller.implementation.TypeControllerImpl;
import br.edu.ufcg.dsc.psoo.mymoney.controller.implementation.UserControllerImpl;
import br.edu.ufcg.dsc.psoo.mymoney.model.bean.Account;
import br.edu.ufcg.dsc.psoo.mymoney.model.bean.Group;
import br.edu.ufcg.dsc.psoo.mymoney.model.bean.Movement;
import br.edu.ufcg.dsc.psoo.mymoney.model.bean.Type;
import br.edu.ufcg.dsc.psoo.mymoney.model.bean.User;
import br.edu.ufcg.dsc.psoo.mymoney.model.hibernate.HibernateAccountDAO;
import br.edu.ufcg.dsc.psoo.mymoney.model.hibernate.HibernateGroupDAO;
import br.edu.ufcg.dsc.psoo.mymoney.model.hibernate.HibernateMovementDAO;
import br.edu.ufcg.dsc.psoo.mymoney.model.hibernate.HibernateTypeDAO;
import br.edu.ufcg.dsc.psoo.mymoney.model.hibernate.HibernateUserDAO;
import br.edu.ufcg.dsc.psoo.mymoney.model.hibernate.HibernateUtil;

/**
 * Fa�ade para testes com o EasyAccept
 * 
 * <p>
 * Teste dos Controllers do sistema MyMoney
 * 
 * @author leonardo
 * @version 1.0
 * 
 */
public class MyMoneyFacade {

	private User loggedUser;
	private Movement createdMovement;
	private Type createdType;
	private Group createdGroup;
	private Account createdAccount;

	HibernateUserDAO userDAO;
	HibernateAccountDAO accountDAO;
	HibernateMovementDAO movementDAO;
	HibernateTypeDAO typeDAO;
	HibernateGroupDAO groupDAO;

	UserController userController;
	AccountController accountController;
	GroupController groupController;
	TypeController typeController;
	MovementController movementController;

	private org.hibernate.Session facadeSession;

	public static final SessionFactory sf = HibernateUtil.getSessionFactory();

	/**<b>Depend�ncia para teste</b><p>
	 * Construtor padr�o que inicializa os DAOs, Controllers e
	 *                 SessionFactory necess�rios aos testes
	 */
//	public MyMoneyFacade() {
//
//		userDAO = new HibernateUserDAO();
//		accountDAO = new HibernateAccountDAO();
//		groupDAO = new HibernateGroupDAO();
//		typeDAO = new HibernateTypeDAO();
//		movementDAO = new HibernateMovementDAO();
//
//		userController = new UserControllerImpl(userDAO);
//		accountController = new AccountControllerImpl(accountDAO);
//		typeController = new TypeControllerImpl(typeDAO);
//		movementController = new MovementControllerImpl(movementDAO, userDAO,
//				groupDAO, accountDAO, typeDAO);
//		groupController = new GroupControllerImpl(groupDAO, accountDAO);
//		
//		/* FIXME
//		 * colocando os sessionFactories dentro dos controllers para
//		 * testar as actions do mentawai
//		 * 
//		 * se preciso depois retornar aqui e arrumar isso
//		 * */
//		
////		userController.setSessionFactory(sf);
//		
//		groupController.setSessionFactory(sf);
////		typeController.setSessionFactory(sf);
////		accountController.setSessionFactory(sf);
//		movementController.setSessionFactory(sf);
//
//		// tipos pre-cadastrados
//		// Type credito = new Type();
//		// credito.setName("Credito");
//		//		
//		// Type debito = new Type();
//		// debito.setName("Debito");
//		//		 
//		// openSession();
//		// typeDAO.create(credito);
//		// typeDAO.create(debito);
//		// closeSession();
//
//	}
//
//	/**
//	 * Chama o m�todo balance em AccountController
//	 * 
//	 * @param name
//	 *            nome da conta
//	 * @return saldo
//	 * @throws AccountNotFoundException
//	 * @throws InvalidUserException
//	 * @throws InvalidAccountException
//	 */
//	public float accountBalance(String name) throws AccountNotFoundException,
//			InvalidUserException, InvalidAccountException {
//
//		openSession();
//		Account account = accountDAO.findByName(name);
//		closeSession();
//
//		Long accountId = null;
//		if (account != null)
//			accountId = account.getId();
//
//		return accountController.balance(loggedUser.getId(), accountId);
//	}
//
//	/**<b>Depend�ncia para teste</b><p>
//	 * Fecha sess�es dos DAOs iniciados localmente para inser��o de depend�ncias
//	 * nos Controllers sob teste
//	 * 
//	 */
//	public void closeSession() {
//		if (facadeSession.isOpen()) {
//			facadeSession.close();
//			userDAO.setSession(facadeSession);
//			typeDAO.setSession(facadeSession);
//			groupDAO.setSession(facadeSession);
//			accountDAO.setSession(facadeSession);
//			movementDAO.setSession(facadeSession);
//		}
//	}
//
//	/**
//	 * Chama o m�todo create em AccounController
//	 * 
//	 * 
//	 * @param login
//	 *            username do usu�rio cadastrado e logado
//	 * @param name
//	 *            nome da nova conta
//	 * @return id da conta criada
//	 * @throws InvalidAccountException
//	 */
//	public Long createAccount(String login, String name)
//			throws InvalidAccountException {
//		Account newAccount = new Account();
//		newAccount.setName(name);
//
//		openSession();
//		User accountUser = userDAO.findByUsername(login);
//		closeSession();
//
//		if (accountUser != null) {
//			User u = new User();
//			u.setId(accountUser.getId());
//			newAccount.setUser(u);
//		}
//		Account account = accountController.create(newAccount);
//
//		openSession();
//		createdAccount = accountDAO.load(account.getId());
//		closeSession();
//
//		return account.getId();
//	}
//
//	/**
//	 * Chama o m�todo create em GroupController
//	 * 
//	 * @param account
//	 *            nome da conta associada ao novo grupo
//	 * @param name
//	 *            nome do novo grupo
//	 * @return id do novo grupo
//	 * @throws InvalidGroupException
//	 * @throws AccountNotFoundException
//	 */
//	public Long createGroup(String account, String name)
//			throws InvalidGroupException, AccountNotFoundException {
//		Group newGroup = new Group();
//		newGroup.setName(name);
//
//		// inserindo dependência
//		openSession();
//		Account groupAccount = accountDAO.findByName(account);
//		closeSession();
//
//		if (groupAccount != null)
//			newGroup.setAccount(groupAccount);
//
//		Group group = groupController.create(newGroup);
//
//		openSession();
//		createdGroup = groupDAO.load(group.getId());
//		closeSession();
//
//		return group.getId();
//	}
//
//	/**
//	 * Chama o m�todo create em MovementController
//
//	 * @param login
//	 *            username do usu�rio cadastrado
//	 * @param accountName
//	 *            nome da conta escolhida
//	 * @param typeName
//	 *            nome do tipo escolhido
//	 * @param groupName
//	 *            nome do grupo escolhido
//	 * @param date
//	 *            data
//	 * @param descripton
//	 *            descri��o opcional
//	 * @param value
//	 *            valor
//	 * @return id da nova movimenta��o
//	 * @throws InvalidMovementException
//	 * @throws InvalidUserException
//	 * @throws java.text.ParseException
//	 *             erro de valida��o do valor
//	 */
//	public Long createMovement(String login, String accountName,
//			String typeName, String groupName, String date, String descripton,
//			String value) throws InvalidMovementException,
//			InvalidUserException, java.text.ParseException {
//		openSession();
//		User movementUser = userDAO.findByUsername(login);
//		Account account = accountDAO.findByName(accountName);
//		Type type = typeDAO.findByName(typeName);
//		//TODO findByName agora retorna lista rever isso GAMBIRRA
//		Group group = groupDAO.findByName(groupName).get(0);
//		closeSession();
//
//		// simulando os IDs das dependências vindos da view
//
//		Long accountId = null, typeId = null, groupId = null;
//
//		if (account != null)
//			accountId = account.getId();
//		if (type != null)
//			typeId = type.getId();
//		if (group != null)
//			groupId = group.getId();
//
//		Long userId = null;
//		if (movementUser != null)
//			userId = movementUser.getId();
//
//		Movement movement = movementController.create(userId, accountId,
//				typeId, groupId, date, descripton, value);
//		openSession();
//		createdMovement = movementDAO.load(movement.getId());
//		closeSession();
//
//		return movement.getId();
//
//	}
//
//	/**
//	 * Chama m�todo create em TypeController
//
//	 * 
//	 * @param login
//	 *            username do usu�rio
//	 * @param name
//	 *            nome do novo tipo
//	 * @return id do novo tipo criado
//	 * @throws InvalidTypeException
//	 */
//	public String createType(String login, String name)
//			throws InvalidTypeException {
//		Type newType = new Type();
//		newType.setName(name);
//		// inserindo dependência
//
//		openSession();
//
//		User user = userDAO.findByUsername(login);
//
//		closeSession();
//
//		if (user != null) {
//			newType.setUser(user);
//		}
//		Type type = typeController.create(newType);
//		openSession();
//		createdType = typeDAO.load(type.getId());
//		closeSession();
//		return type.getId().toString();
//	}
//
//	/**
//	 * Chama o m�todo create em UserController
//	 * @param name
//	 * @param password
//	 * @param confirmation
//	 * @param email
//	 * @return id do usu�rio criado
//	 * @throws InvalidUserException
//	 */
//	public String createUser(String name, String password, String confirmation,
//			String email) throws InvalidUserException {
//		User newUser = new User();
//		newUser.setUsername(name);
//		newUser.setPassword(password);
//		newUser.setConfirmation(confirmation);
//		newUser.setEmail(email);
//		loggedUser = userController.create(newUser);
//
//		return loggedUser.getId().toString();
//	}
//
//	/**
//	 * Chama o m�todo delete em AccountController
//	 * 
//	 * @param login
//	 *            usu�rio logado
//	 * @param name
//	 *            nome da conta
//	 * @throws InvalidAccountException
//	 * @throws AccountNotFoundException
//	 *             exce��o de conta nao encontrada
//	 */
//	public void deleteAccount(String login, String name)
//			throws InvalidAccountException, AccountNotFoundException {
//
//		openSession();
//		User accountDeleteUser = userDAO.findByUsername(login);
//		closeSession();
//
//		Long userId = null;
//		if (accountDeleteUser != null)
//			userId = accountDeleteUser.getId();
//
//		openSession();
//		Account account = accountDAO.findByName(name);
//		closeSession();
//
//		Long id = null;
//		if (account != null)
//			id = account.getId();
//
//		accountController.delete(id, userId);
//	}
//
//	/**<b>Depend�ncia para teste</b><p>
//	 * Apaga todas as contas cadastradas em banco
//	 * 
//	 * 
//	 * @throws InvalidAccountException
//	 *             exce��o gen�rica
//	 */
//	public void deleteAllAccounts() throws InvalidAccountException {
//		openSession();
//		Account a = new Account();
//
//		List<Account> list = accountDAO.find(a);
//		if (list.size() == 0)
//			throw new InvalidAccountException("Nothing to delete!");
//		for (Account account : list) {
//			accountDAO.delete(account);
//		}
//		closeSession();
//	}
//
//	/** 
//	 * <b>Depend�ncia para teste</b><p>
//	 * 
//	 * Apaga todos os grupos cadastrados em banco
//	 * 
//	 * @throws InvalidGroupException
//	 *             exce��o gen�rica
//	 */
//	public void deleteAllGroups() throws InvalidGroupException {
//		openSession();
//		Group group = new Group();
//
//		List<Group> list = groupDAO.find(group);
//		if (list.size() == 0)
//			throw new InvalidGroupException("Nothing to delete!");
//		for (Group g : list) {
//			groupDAO.delete(g);
//		}
//		closeSession();
//	}
//
//	/**<b>Depend�ncia para teste</b><p>
//	 * Apaga todas as movimenta��es cadastradas em banco
//	 * 
//	 * @throws InvalidMovementException
//	 *             exce��o gen�rica
//	 */
//	public void deleteAllMovements() throws InvalidMovementException {
//		openSession();
//		Movement u = new Movement();
//
//		List<Movement> list = movementDAO.find(u);
//		if (list.size() == 0)
//			throw new InvalidMovementException("Nothing to delete!");
//		for (Movement movement : list) {
//			movementDAO.delete(movement);
//		}
//		closeSession();
//	}
//
//	/**
//	 * <b>Depend�ncia para teste</b><p>
//	 * Apaga todos os tipos cadastrados em banco
//	 * 
//	 * @throws InvalidTypeException
//	 *             exce��o gen�rica
//	 */
//	public void deleteAllTypes() throws InvalidTypeException {
//		openSession();
//		Type t = new Type();
//
//		List<Type> list = typeDAO.find(t);
//		if (list.size() == 0)
//			throw new InvalidTypeException("Nothing to delete!");
//		for (Type type : list) {
//			typeDAO.delete(type);
//		}
//		closeSession();
//	}
//
//	/**
//	 * <b>Depend�ncia para teste</b><p>
//	 * Apaga todos os usu�rios cadastrados em banco
//	 * 
//	 * @throws InvalidUserException
//	 *             exce��o gen�rica
//	 */
//	public void deleteAllUsers() throws InvalidUserException {
//		openSession();
//		User u = new User();
//
//		List<User> list = userDAO.find(u);
//		if (list.size() == 0)
//			throw new InvalidUserException("Test Error: Nada para deletar!");
//		for (User user : list) {
//			userDAO.delete(user);
//		}
//		closeSession();
//	}
//
//	/**
//	 * Chama o m�todo delete em GroupController
//	 * @param account
//	 *            nome da conta
//	 * @param name
//	 *            nome do grupo
//	 * @throws InvalidGroupException
//	 * @throws GroupNotFoundException
//	 */
//	public void deleteGroup(String account, String name)
//			throws InvalidGroupException, GroupNotFoundException {
//
//		openSession();
//		Account bdAccount = accountDAO.findByName(account);
//		//TODO findByName agora retorna lista rever isso GAMBIRRA
//		Group g = groupDAO.findByName(name).get(0);
//		closeSession();
//
//		Long id = null;
//		if (g != null)
//			id = g.getId();
//
//		Long accountId = null;
//		if (bdAccount != null)
//			accountId = bdAccount.getId();
//
//		groupController.delete(accountId, id);
//	}
//
//	/**
//	 * Chama o m�todo delete em MovementController
//	 * @param account
//	 * @param id
//	 * @throws InvalidMovementException
//	 */
//	public void deleteMovement(String account, Long id)
//			throws InvalidMovementException {
//		openSession();
//		Account bdAccount = accountDAO.findByName(account);
//		closeSession();
//		Long accountId = null;
//		if (bdAccount != null)
//			accountId = bdAccount.getId();
//
//		movementController.delete(id, accountId);
//	}
//
//	/**
//	 * Chama o m�todo delete em TypeController
//	 * @param login
//	 *            usu�rio logado
//	 * @param name
//	 *            nome do tipo
//	 * @throws InvalidTypeException
//	 * @throws TypeNotFoundException
//	 */
//	public void deleteType(String login, String name)
//			throws InvalidTypeException, TypeNotFoundException {
//		openSession();
//		User typeDeleteUser = userDAO.findByUsername(login);
//		closeSession();
//
//		Long userId = null;
//		if (typeDeleteUser != null)
//			userId = typeDeleteUser.getId();
//
//		openSession();
//		Type type = typeDAO.findByName(name);
//		closeSession();
//
//		Long id = null;
//		if (type != null)
//			id = type.getId();
//
//		typeController.delete(id, userId);
//	}
//
//	/**<b>Depend�ncia para teste</b><p>
//	 * Apaga usu�rio cadastrado
//	 * @param id
//	 *            identificador do usu�rio
//	 */
//	public void deleteUser(Long id) {
//		User u = new User();
//		u.setId(id);
//
//		org.hibernate.Session session = sf.openSession();
//		userDAO.setSession(session);
//		userDAO.delete(u);
//		session.close();
//		userDAO.setSession(session);
//	}
//
//	/**<b>Depend�ncia para teste</b><p>
//	 * Retorna nome da conta criada
//	 * @return nome da conta
//	 */
//	public String getAccountName() {
//		return createdAccount.getName();
//	}
//
//	/**<b>Depend�ncia para teste</b><p>
//	 * Retorna nome do usu�rio da conta criada
//	 * @param name
//	 *            nome da conta
//	 * @return nome do usu�rio
//	 */
//	public String getAccountUser(String name) {
//		openSession();
//		Account account = accountDAO.findByName(name);
//		closeSession();
//		// User accountUser = userDAO.load(account.getUser());
//		return account.getUser().getUsername();
//	}
//
//	/**<b>Depend�ncia para teste</b><p>
//	 * Retorna nome do grupo criado
//	 * @return nome
//	 */
//	public String getGroupName() {
//		return createdGroup.getName();
//	}
//
//	/**<b>Depend�ncia para teste</b><p>
//	 * Retorna nome do usu�rio criador do grupo
//	 * @param name
//	 *            nome do grupo
//	 * @return nome do usu�rio
//	 */
//	public String getGroupUser(String name) {
//		openSession();
//		//TODO findByName agora retorna lista rever isso GAMBIRRA
//		Group group = groupDAO.findByName(name).get(0);
//		closeSession();
//		return group.getAccount().getUser().getUsername();
//	}
//
//	/**<b>Depend�ncia para teste</b><p>
//	 * Retorna id do usu�rio logado
//	 * @return id
//	 */
//	public Long getLoggedUserId() {
//		return loggedUser.getId();
//	}
//
//	/**<b>Depend�ncia para teste</b><p>
//	 * Retorna nome do usu�rio logado
//	 * @return login
//	 */
//	public String getLoggedUserLogin() {
//		return loggedUser.getUsername();
//	}
//
//	/**<b>Depend�ncia para teste</b><p>
//	 * Retorna password do usu�rio logado
//	 * @return password
//	 */
//	public String getLoggedUserPassword() {
//		return loggedUser.getPassword();
//	}
//
//	/**<b>Depend�ncia para teste</b><p>
//	 * Retorna nome da conta associada a movimenta��o criada
//	 * @return nome
//	 */
//	public String getMovementAccount() {
//		return createdMovement.getAccount().getName();
//	}
//
//	/**<b>Depend�ncia para teste</b><p>
//	 * Retorna data da movimenta��o criada
//	 * @return data
//	 */
//	public String getMovementDate() {
//		return createdMovement.getDate().toString();
//	}
//
//	/**<b>Depend�ncia para teste</b><p>
//	 * Retorna a descri��o da movimenta��o criada
//	 * @return descri��o
//	 */
//	public String getMovementDescription() {
//		return createdMovement.getDescription();
//	}
//
//	/**<b>Depend�ncia para teste</b><p>
//	 * Retorna nome do grupo associado a movimenta��o criada
//	 * @return nome do grupo
//	 */
//	public String getMovementGroup() {
//		return createdMovement.getGroup().getName();
//	}
//
//	/**<b>Depend�ncia para teste</b><p>
//	 * Retorna nome do tipo da movimenta��o criada
//	 * @return nome do tipo
//	 */
//	public String getMovementType() {
//		return createdMovement.getType().getName();
//	}
//
//	/**<b>Depend�ncia para teste</b><p>
//	 * Retorna nome do usu�rio associado a movimenta��o criada
//	 * @return nome do usu�rio
//	 */
//	public String getMovementUser() {
//		return createdMovement.getAccount().getUser().getUsername();
//
//	}
//
//	/**<b>Depend�ncia para teste</b><p>
//	 * Retorna valor da movimenta��o criada
//	 * @return valor
//	 */
//	public Float getMovementValue() {
//		return createdMovement.getValue();
//	}
//
//	/**<b>Depend�ncia para teste</b><p>
//	 * Retorna nome do tipo criado
//	 * @return nome
//	 */
//	public String getTypeName() {
//		return createdType.getName();
//	}
//
//	/**<b>Depend�ncia para teste</b><p>
//	 * Retorna nome do usu�rio associado ao tipo criado
//	 * @param name
//	 * @return nome do usu�rio
//	 */
//	public String getTypeUser(String name) {
//		Type type = typeDAO.findByName(name);
//
//		return type.getUser().getUsername();
//	}
//
//	/**
//	 * Chama o m�todo importFile em MovementController
//	 * 
//	 * @param fileName
//	 *            nome do arquivo
//	 * @return numero de movimenta��es inclu�das
//	 * @throws FileNotFoundException
//	 * @throws InvalidFileException
//	 * @throws GroupNotFoundException
//	 * @throws TypeNotFoundException
//	 * @throws AccountNotFoundException
//	 * @throws InvalidMovementException
//	 * @throws InvalidUserException
//	 * @throws java.text.ParseException
//	 */
//	public int importFile(String fileName) throws FileNotFoundException,
//			InvalidFileException, GroupNotFoundException,
//			TypeNotFoundException, AccountNotFoundException,
//			InvalidMovementException, InvalidUserException,
//			java.text.ParseException {
//
//		return movementController.importFile(loggedUser.getId(), fileName)
//				.size();
//
//	}
//
//	/**
//	 * Chama o m�todo log em UserController
//	 * 
//	 * @param name
//	 * @param password
//	 * @throws InvalidUserException
//	 */
//	public void loginUser(String name, String password)
//			throws InvalidUserException {
//
//		loggedUser = userController.log(name, password);
//
//	}
//
//	/**
//	 * Chama o metodo logoff de UserController
//	 * 
//	 * @param login
//	 *            nome do usu�rio
//	 * @throws UserNotFoundException
//	 * @throws InvalidUserException
//	 */
//	public void logoffUser(String login) throws UserNotFoundException,
//			InvalidUserException {
//
//		User user = new User();
//		user.setUsername(login);
//
//		loggedUser = userController.logoff(user);
//
//	}
//
//	/**
//	 * Chama o m�todo notify em MovementController
//	 * @param account
//	 *            nome da conta
//	 * @param initialDate
//	 *            data atual
//	 * @return quantidade de movimenta��es futuras
//	 * @throws InvalidMovementException
//	 * @throws AccountNotFoundException
//	 */
//	public int notification(String account, String initialDate)
//			throws InvalidMovementException, AccountNotFoundException {
//		openSession();
//		Account bdAccount = accountDAO.findByName(account);
//		closeSession();
//
//		if (bdAccount == null)
//			throw new AccountNotFoundException("Account not found!");
//
//		return movementController.notify(account, initialDate).size();
//	}
//
//	/**<b>Depend�ncia para teste</b><p>
//	 * Abre sess�es dos DAOs iniciados localmente para inser��o de depend�ncias
//	 * nos Controllers sob teste
//	 * 
//	 */
//	public void openSession() {
//		facadeSession = sf.openSession();
//		userDAO.setSession(facadeSession);
//		typeDAO.setSession(facadeSession);
//		groupDAO.setSession(facadeSession);
//		accountDAO.setSession(facadeSession);
//		movementDAO.setSession(facadeSession);
//	}
//
//	/**
//	 * Chama o m�todo search em MovementController <br>
//	 * <b>Usado nos testes de unidade</b>
//	 * @param order
//	 *            crit�rio de ordena��o
//	 * @param account
//	 *            filtro de conta
//	 * @param type
//	 *            filtro de tipo
//	 * @param group
//	 *            filtro de grupo
//	 * @param initialDate
//	 *            filtro de data inicial
//	 * @param finalDate
//	 *            filtro de data final
//	 * @param description
//	 *            filtro de descri��o
//	 * @return movimenta��es encontradas
//	 * @throws InvalidMovementException
//	 *             erro de valida��o de datas
//	 */
//	public List<Movement> search(String order, String account, String type,
//			String group, String initialDate, String finalDate,
//			String description) throws InvalidMovementException {
//
//		List<Movement> list = movementController.searchMovement(order, account,
//				type, group, initialDate, finalDate, description);
//
//		return list;
//	}
//
//	/**
//	 * Chama o m�todo search em MovementController
//	 * @param order
//	 *            crit�rio de ordena��o
//	 * @param account
//	 *            filtro de conta
//	 * @param type
//	 *            filtro de tipo
//	 * @param group
//	 *            filtro de grupo
//	 * @param initialDate
//	 *            filtro de data inicial
//	 * @param finalDate
//	 *            filtro de data final
//	 * @param description
//	 *            filtro de descri��o
//	 * @return movimenta��es encontradas
//	 * @throws InvalidMovementException
//	 *             erro de valida��o de datas
//	 */
//	public int searchMovement(String order, String account, String type,
//			String group, String initialDate, String finalDate,
//			String description) throws InvalidMovementException {
//
//		List<Movement> list = movementController.searchMovement(order, account,
//				type, group, initialDate, finalDate, description);
//
//		return list.size();
//	}
//
//	/**<b>Depend�ncia para teste</b><p>
//	 * Chama o m�todo totalBalance em UserDAO
//	 * 
//	 * @return saldo total
//	 */
//	public float totalBalance() {
//		openSession();
//		float result = userDAO.totalBalance(loggedUser.getId());
//		closeSession();
//		return result;
//	}
//
//	/**
//	 * Chama o m�todo update em AccountController
//	 * 
//	 * @param id
//	 *            id da conta
//	 * @param login
//	 *            nome de usu�rio logado
//	 * @param name
//	 *            novo nome da conta
//	 * @return conta alterada
//	 * @throws InvalidAccountException
//	 *             erro de valida��o de campos
//	 */
//	public Account updateAccount(Long id, String login, String name)
//			throws InvalidAccountException {
//		Account newAccount = new Account();
//		newAccount.setName(name);
//		newAccount.setId(id);
//
//		openSession();
//		User accountUser = userDAO.findByUsername(login);
//		closeSession();
//
//		if (accountUser != null) {
//			newAccount.setUser(accountUser);
//		}
//
//		Account account = accountController.update(newAccount);
//
//		openSession();
//		createdAccount = accountDAO.load(account.getId());
//		closeSession();
//		return account;
//	}
//
//	/**
//	 * Chama m�todo update em GroupController
//	 * 
//	 * @param id
//	 *            identificador do grupo
//	 * @param account
//	 *            nome da conta associada ao grupo
//	 * @param name
//	 *            novo nome do grupo
//	 * @return grupo criado
//	 * @throws InvalidGroupException
//	 *             erro de valida��o de campos
//	 */
//	public Group updateGroup(Long id, String account, String name)
//			throws InvalidGroupException {
//
//		Group newGroup = new Group();
//		newGroup.setName(name);
//		newGroup.setId(id);
//
//		// inserindo dependência
//		openSession();
//		Account groupAccount = accountDAO.findByName(account);
//		closeSession();
//
//		if (groupAccount != null)
//			newGroup.setAccount(groupAccount);
//
//		Group group = groupController.update(newGroup);
//
//		openSession();
//		createdGroup = groupDAO.load(group.getId());
//		closeSession();
//
//		return group;
//	}
//
//	/**
//	 * Chama m�todo update em MovementController
//	 * 
//	 * @param id
//	 *            identificador da movimenta��o
//	 * @param login
//	 *            username do usu�rio logado
//	 * @param accountName
//	 *            nome da conta associada a movimenta��o
//	 * @param typeName
//	 *            nome do tipo associado a movimenta��o
//	 * @param groupName
//	 *            nome do grupo associado a movimenta��o
//	 * @param date
//	 *            daqta
//	 * @param descripton
//	 *            descri��o opicional
//	 * @param value
//	 *            valor
//	 * @return movimenta��o criada
//	 * @throws InvalidMovementException
//	 *             erro de valida��o de campos
//	 * @throws InvalidUserException
//	 *             usu�rio n�o encontrado
//	 * @throws java.text.ParseException
//	 *             erro na valida��o de valor
//	 */
//	public Movement updateMovement(Long id, String login, String accountName,
//			String typeName, String groupName, String date, String descripton,
//			String value) throws InvalidMovementException,
//			InvalidUserException, java.text.ParseException {
//		openSession();
//		User movementUser = userDAO.findByUsername(login);
//		Account account = accountDAO.findByName(accountName);
//		Type type = typeDAO.findByName(typeName);
//		//TODO findByName agora retorna lista rever isso GAMBIRRA
//		Group group = groupDAO.findByName(groupName).get(0);
//		closeSession();
//
//		// simulando os IDs das dependências vindos da view
//
//		Long accountId = null, typeId = null, groupId = null;
//
//		if (account != null)
//			accountId = account.getId();
//		if (type != null)
//			typeId = type.getId();
//		if (group != null)
//			groupId = group.getId();
//
//		Long userId = null;
//		if (movementUser != null)
//			userId = movementUser.getId();
//
//		Movement movement = movementController.update(id, userId, accountId,
//				typeId, groupId, date, descripton, value);
//		openSession();
//		createdMovement = movementDAO.load(movement.getId());
//		closeSession();
//
//		return movement;
//	}
//
//	/**
//	 * Chama m�todo update em TypeController
//	 * @param id
//	 *            identificador do tipo
//	 * @param login
//	 *            username do usu�rio logado
//	 * @param name
//	 * @return tipo atualizado
//	 * @throws InvalidTypeException
//	 */
//	public Type updateType(Long id, String login, String name)
//			throws InvalidTypeException {
//		Type newType = new Type();
//		newType.setName(name);
//		newType.setId(id);
//
//		// inserindo dependência
//		openSession();
//		User typeUser = userDAO.findByUsername(login);
//		closeSession();
//		if (typeUser != null) {
//
//			newType.setUser(typeUser);
//		}
//
//		Type type = typeController.update(newType);
//
//		openSession();
//		createdType = typeDAO.load(type.getId());
//		closeSession();
//
//		return type;
//	}
//
//	/**
//	 * Chama m�todo update em UserController
//	 * @param id
//	 *            identificador de usu�rio
//	 * @param name
//	 *            novo nome do usu�rio
//	 * @param password
//	 *            novo password
//	 * @param confirmation
//	 *            confirma��o de password
//	 * @param email
//	 *            email
//	 * @return usu�rio atualizado
//	 * @throws InvalidUserException
//	 *             erro de valida��o
//	 */
//	public User updateUser(Long id, String name, String password,
//			String confirmation, String email) throws InvalidUserException {
//		User newUser = new User();
//		newUser.setId(id);
//		newUser.setUsername(name);
//		newUser.setPassword(password);
//		newUser.setConfirmation(confirmation);
//		newUser.setEmail(email);
//		loggedUser = userController.update(newUser);
//		return loggedUser;
//	}

}